
声明 模块 "zlib" {

    //@@{ 流:stream }
    导入 * 转为 流 来自 "stream";

    //@@{ Zlib选项_:ZlibOptions }
    接口 Zlib选项_ {
        /**
         * @default constants.Z_NO_FLUSH
         */

        //@@{ 刷新:flush }
        刷新?: 数字;
        /**
         * @default constants.Z_FINISH
         */

        //@@{ 完成刷新:finishFlush }
        完成刷新?: 数字;
        /**
         * @default 16*1024
         */

        //@@{ 块大小:chunkSize }
        块大小?: 数字;

        //@@{ 窗口位:windowBits }
        窗口位?: 数字;

        //@@{ 级别:level }
        级别?: 数字; // compression only

        //@@{ 内存级别:memLevel }
        内存级别?: 数字; // compression only

        //@@{ 策略:strategy }
        策略?: 数字; // compression only

        //@@{ 字典:dictionary, 缓冲区_:Buffer, 类型数组_:TypedArray, 数据视图_:DataView, 数组缓冲区_:ArrayBuffer }
        字典?: 缓冲区_ | NodeJS.类型数组_ | 数据视图_ | 数组缓冲区_; // deflate/inflate only, empty dictionary by default
    }

    //@@{ 布洛利选项_:BrotliOptions }
    接口 布洛利选项_ {
        /**
         * @default constants.BROTLI_OPERATION_PROCESS
         */

        //@@{ 刷新:flush }
        刷新?: 数字;
        /**
         * @default constants.BROTLI_OPERATION_FINISH
         */

        //@@{ 完成刷新:finishFlush }
        完成刷新?: 数字;
        /**
         * @default 16*1024
         */

        //@@{ 块大小:chunkSize }
        块大小?: 数字;

        //@@{ 参数组:params }
        参数组?: {
            /**
             * Each key is a `constants.BROTLI_*` constant.
             */
            [key: 数字]: 真假 | 数字;
        };
    }

    接口 Zlib {
        /** @deprecated Use bytesWritten instead. */

        //@@{ 字节读:bytesRead }
        只读 字节读: 数字;

        //@@{ 字节写:bytesWritten }
        只读 字节写: 数字;

        //@@{ 界面:shell }
        界面?: 真假 | 文字;

        //@@{ 关闭:close }
        关闭(回调?: () => 无值): 无值;

        //@@{ 刷新:flush }
        刷新(种类?: 数字 | (() => 无值), 回调?: () => 无值): 无值;
    }

    //@@{ ZLIB参数_:ZlibParams }
    接口 ZLIB参数_ {

        //@@{ 参数组:params }
        参数组(级别: 数字, 策略: 数字, 回调: () => 无值): 无值;
    }

    //@@{ ZLIB复位_:ZlibReset }
    接口 ZLIB复位_ {

        //@@{ 重置:reset }
        重置(): 无值;
    }

    //@@{ 布洛利压缩_:BrotliCompress, 流:stream, 变换_:Transform }
    接口 布洛利压缩_ 扩展 流.变换_, Zlib { }

    //@@{ 布洛利解压_:BrotliDecompress, 流:stream, 变换_:Transform }
    接口 布洛利解压_ 扩展 流.变换_, Zlib { }

    //@@{ 流:stream, 变换_:Transform }
    接口 Gzip 扩展 流.变换_, Zlib { }

    //@@{ 解压Gzip_:Gunzip, 流:stream, 变换_:Transform }
    接口 解压Gzip_ 扩展 流.变换_, Zlib { }

    //@@{ 无损压缩_:Deflate, 流:stream, 变换_:Transform, ZLIB复位_:ZlibReset, ZLIB参数_:ZlibParams }
    接口 无损压缩_ 扩展 流.变换_, Zlib, ZLIB复位_, ZLIB参数_ { }

    //@@{ 解压无损_:Inflate, 流:stream, 变换_:Transform, ZLIB复位_:ZlibReset }
    接口 解压无损_ 扩展 流.变换_, Zlib, ZLIB复位_ { }

    //@@{ 无损压缩原始_:DeflateRaw, 流:stream, 变换_:Transform, ZLIB复位_:ZlibReset, ZLIB参数_:ZlibParams }
    接口 无损压缩原始_ 扩展 流.变换_, Zlib, ZLIB复位_, ZLIB参数_ { }

    //@@{ 解压无损原始_:InflateRaw, 流:stream, 变换_:Transform, ZLIB复位_:ZlibReset }
    接口 解压无损原始_ 扩展 流.变换_, Zlib, ZLIB复位_ { }

    //@@{ 解压_:Unzip, 流:stream, 变换_:Transform }
    接口 解压_ 扩展 流.变换_, Zlib { }

    //@@{ 创建布洛利压缩:createBrotliCompress, 布洛利选项_:BrotliOptions, 布洛利压缩_:BrotliCompress }
    函数 创建布洛利压缩(选项组?: 布洛利选项_): 布洛利压缩_;

    //@@{ 创建布洛利解压缩:createBrotliDecompress, 布洛利选项_:BrotliOptions, 布洛利解压_:BrotliDecompress }
    函数 创建布洛利解压缩(选项组?: 布洛利选项_): 布洛利解压_;

    //@@{ 创建Gzip:createGzip, Zlib选项_:ZlibOptions }
    函数 创建Gzip(选项组?: Zlib选项_): Gzip;

    //@@{ 创建解压Gzip:createGunzip, Zlib选项_:ZlibOptions, 解压Gzip_:Gunzip }
    函数 创建解压Gzip(选项组?: Zlib选项_): 解压Gzip_;

    //@@{ 创建无损压缩:createDeflate, Zlib选项_:ZlibOptions, 无损压缩_:Deflate }
    函数 创建无损压缩(选项组?: Zlib选项_): 无损压缩_;

    //@@{ 创建解压无损:createInflate, Zlib选项_:ZlibOptions, 解压无损_:Inflate }
    函数 创建解压无损(选项组?: Zlib选项_): 解压无损_;

    //@@{ 创建无损压缩原始:createDeflateRaw, Zlib选项_:ZlibOptions, 无损压缩原始_:DeflateRaw }
    函数 创建无损压缩原始(选项组?: Zlib选项_): 无损压缩原始_;

    //@@{ 创建解压无损原始:createInflateRaw, Zlib选项_:ZlibOptions, 解压无损原始_:InflateRaw }
    函数 创建解压无损原始(选项组?: Zlib选项_): 解压无损原始_;

    //@@{ 创建解压:createUnzip, Zlib选项_:ZlibOptions, 解压_:Unzip }
    函数 创建解压(选项组?: Zlib选项_): 解压_;

    //@@{ 输入类型_:InputType, 缓冲区_:Buffer, 数据视图_:DataView, 数组缓冲区_:ArrayBuffer, 类型数组_:TypedArray }
    类型 输入类型_ = 文字 | 缓冲区_ | 数据视图_ | 数组缓冲区_ | NodeJS.类型数组_;

    //@@{ 压缩回调_:CompressCallback, 错误_:Error, 缓冲区_:Buffer }
    类型 压缩回调_ = (错误: 错误_ | 空值, 结果: 缓冲区_) => 无值;

    //@@{ 布洛利压缩:brotliCompress, 输入类型_:InputType, 布洛利选项_:BrotliOptions, 压缩回调_:CompressCallback }
    函数 布洛利压缩(缓冲: 输入类型_, 选项组: 布洛利选项_, 回调: 压缩回调_): 无值;

    //@@{ 布洛利压缩:brotliCompress, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 布洛利压缩(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 布洛利压缩同步:brotliCompressSync, 输入类型_:InputType, 布洛利选项_:BrotliOptions }
    //@@{ 缓冲区_:Buffer }
    函数 布洛利压缩同步(缓冲: 输入类型_, 选项组?: 布洛利选项_): 缓冲区_;

    //@@{ 布洛利解压组:brotliDecompress, 输入类型_:InputType, 布洛利选项_:BrotliOptions, 压缩回调_:CompressCallback }
    函数 布洛利解压组(缓冲: 输入类型_, 选项组: 布洛利选项_, 回调: 压缩回调_): 无值;

    //@@{ 布洛利解压组:brotliDecompress, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 布洛利解压组(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 布洛利解压缩同步:brotliDecompressSync, 输入类型_:InputType, 布洛利选项_:BrotliOptions }
    //@@{ 缓冲区_:Buffer }
    函数 布洛利解压缩同步(缓冲: 输入类型_, 选项组?: 布洛利选项_): 缓冲区_;

    //@@{ 无损解压:deflate, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 无损解压(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 无损解压:deflate, 输入类型_:InputType, Zlib选项_:ZlibOptions, 压缩回调_:CompressCallback }
    函数 无损解压(缓冲: 输入类型_, 选项组: Zlib选项_, 回调: 压缩回调_): 无值;

    //@@{ 无损解压同步:deflateSync, 输入类型_:InputType, Zlib选项_:ZlibOptions, 缓冲区_:Buffer }
    函数 无损解压同步(缓冲: 输入类型_, 选项组?: Zlib选项_): 缓冲区_;

    //@@{ 无损解压原始:deflateRaw, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 无损解压原始(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 无损解压原始:deflateRaw, 输入类型_:InputType, Zlib选项_:ZlibOptions, 压缩回调_:CompressCallback }
    函数 无损解压原始(缓冲: 输入类型_, 选项组: Zlib选项_, 回调: 压缩回调_): 无值;

    //@@{ 无损解压原始同步:deflateRawSync, 输入类型_:InputType, Zlib选项_:ZlibOptions, 缓冲区_:Buffer }
    函数 无损解压原始同步(缓冲: 输入类型_, 选项组?: Zlib选项_): 缓冲区_;

    //@@{ 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 gzip(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 输入类型_:InputType, Zlib选项_:ZlibOptions, 压缩回调_:CompressCallback }
    函数 gzip(缓冲: 输入类型_, 选项组: Zlib选项_, 回调: 压缩回调_): 无值;

    //@@{ gzip同步:gzipSync, 输入类型_:InputType, Zlib选项_:ZlibOptions, 缓冲区_:Buffer }
    函数 gzip同步(缓冲: 输入类型_, 选项组?: Zlib选项_): 缓冲区_;

    //@@{ 解压Gzip:gunzip, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 解压Gzip(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 解压Gzip:gunzip, 输入类型_:InputType, Zlib选项_:ZlibOptions, 压缩回调_:CompressCallback }
    函数 解压Gzip(缓冲: 输入类型_, 选项组: Zlib选项_, 回调: 压缩回调_): 无值;

    //@@{ 解压Gzip同步:gunzipSync, 输入类型_:InputType, Zlib选项_:ZlibOptions, 缓冲区_:Buffer }
    函数 解压Gzip同步(缓冲: 输入类型_, 选项组?: Zlib选项_): 缓冲区_;

    //@@{ 解压无损:inflate, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 解压无损(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 解压无损:inflate, 输入类型_:InputType, Zlib选项_:ZlibOptions, 压缩回调_:CompressCallback }
    函数 解压无损(缓冲: 输入类型_, 选项组: Zlib选项_, 回调: 压缩回调_): 无值;

    //@@{ 解压无损同步:inflateSync, 输入类型_:InputType, Zlib选项_:ZlibOptions, 缓冲区_:Buffer }
    函数 解压无损同步(缓冲: 输入类型_, 选项组?: Zlib选项_): 缓冲区_;

    //@@{ 解压无损原始:inflateRaw, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 解压无损原始(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 解压无损原始:inflateRaw, 输入类型_:InputType, Zlib选项_:ZlibOptions, 压缩回调_:CompressCallback }
    函数 解压无损原始(缓冲: 输入类型_, 选项组: Zlib选项_, 回调: 压缩回调_): 无值;

    //@@{ 解压无损原始同步:inflateRawSync, 输入类型_:InputType, Zlib选项_:ZlibOptions, 缓冲区_:Buffer }
    函数 解压无损原始同步(缓冲: 输入类型_, 选项组?: Zlib选项_): 缓冲区_;

    //@@{ 解压:unzip, 输入类型_:InputType, 压缩回调_:CompressCallback }
    函数 解压(缓冲: 输入类型_, 回调: 压缩回调_): 无值;

    //@@{ 解压:unzip, 输入类型_:InputType, Zlib选项_:ZlibOptions, 压缩回调_:CompressCallback }
    函数 解压(缓冲: 输入类型_, 选项组: Zlib选项_, 回调: 压缩回调_): 无值;

    //@@{ 解压同步:unzipSync, 输入类型_:InputType, Zlib选项_:ZlibOptions, 缓冲区_:Buffer }
    函数 解压同步(缓冲: 输入类型_, 选项组?: Zlib选项_): 缓冲区_;

    //@@{ 常量组:constants }
    名域 常量组 {

        //@@{ __布洛利_解码__:BROTLI_DECODE }
        常量 __布洛利_解码__: 数字;

        //@@{ __布洛利_解码_错误_分配内存_块_类型_树__:BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES }
        常量 __布洛利_解码_错误_分配内存_块_类型_树__: 数字;

        //@@{ __布洛利_解码_错误_分配内存_上下文_映射__:BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP }
        常量 __布洛利_解码_错误_分配内存_上下文_映射__: 数字;

        //@@{ __布洛利_解码_错误_分配内存_上下文_模式__:BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES }
        常量 __布洛利_解码_错误_分配内存_上下文_模式__: 数字;

        //@@{ __布洛利_解码_错误_分配内存_环形_缓冲区_1__:BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1 }
        常量 __布洛利_解码_错误_分配内存_环形_缓冲区_1__: 数字;

        //@@{ __布洛利_解码_错误_分配内存_环形_缓冲区_2__:BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2 }
        常量 __布洛利_解码_错误_分配内存_环形_缓冲区_2__: 数字;

        //@@{ __布洛利_解码_错误_分配内存_数_群组__:BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS }
        常量 __布洛利_解码_错误_分配内存_数_群组__: 数字;

        //@@{ __布洛利_解码_错误_未_设置_词典__:BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET }
        常量 __布洛利_解码_错误_未_设置_词典__: 数字;

        //@@{ __布洛利_解码_错误_格式化_块_长度_1__:BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1 }
        常量 __布洛利_解码_错误_格式化_块_长度_1__: 数字;

        //@@{ __布洛利_解码_错误_格式化_块_长度_2__:BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2 }
        常量 __布洛利_解码_错误_格式化_块_长度_2__: 数字;

        //@@{ __布洛利_解码_错误_格式化_CL_空间__:BROTLI_DECODER_ERROR_FORMAT_CL_SPACE }
        常量 __布洛利_解码_错误_格式化_CL_空间__: 数字;

        //@@{ __布洛利_解码_错误_格式化_上下文_映射_重复__:BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT }
        常量 __布洛利_解码_错误_格式化_上下文_映射_重复__: 数字;

        //@@{ __布洛利_解码_错误_格式化_词典__:BROTLI_DECODER_ERROR_FORMAT_DICTIONARY }
        常量 __布洛利_解码_错误_格式化_词典__: 数字;

        //@@{ __布洛利_解码_错误_格式化_距离__:BROTLI_DECODER_ERROR_FORMAT_DISTANCE }
        常量 __布洛利_解码_错误_格式化_距离__: 数字;

        //@@{ __布洛利_解码_错误_格式化_旺盛_元_蚕食__:BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE }
        常量 __布洛利_解码_错误_格式化_旺盛_元_蚕食__: 数字;

        //@@{ __布洛利_解码_错误_格式化_旺盛_蚕食__:BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE }
        常量 __布洛利_解码_错误_格式化_旺盛_蚕食__: 数字;

        //@@{ __布洛利_解码_错误_格式化_哈夫曼_空间__:BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE }
        常量 __布洛利_解码_错误_格式化_哈夫曼_空间__: 数字;

        //@@{ __布洛利_解码_错误_格式化_填充_1__:BROTLI_DECODER_ERROR_FORMAT_PADDING_1 }
        常量 __布洛利_解码_错误_格式化_填充_1__: 数字;

        //@@{ __布洛利_解码_错误_格式化_填充_2__:BROTLI_DECODER_ERROR_FORMAT_PADDING_2 }
        常量 __布洛利_解码_错误_格式化_填充_2__: 数字;

        //@@{ __布洛利_解码_错误_格式化_保留__:BROTLI_DECODER_ERROR_FORMAT_RESERVED }
        常量 __布洛利_解码_错误_格式化_保留__: 数字;

        //@@{ __布洛利_解码_错误_格式化_简单_哈夫曼_字母表__:BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET }
        常量 __布洛利_解码_错误_格式化_简单_哈夫曼_字母表__: 数字;

        //@@{ __布洛利_解码_错误_格式化_简单_哈夫曼_相同__:BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME }
        常量 __布洛利_解码_错误_格式化_简单_哈夫曼_相同__: 数字;

        //@@{ __布洛利_解码_错误_格式化_变换__:BROTLI_DECODER_ERROR_FORMAT_TRANSFORM }
        常量 __布洛利_解码_错误_格式化_变换__: 数字;

        //@@{ __布洛利_解码_错误_格式化_窗口_比特__:BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS }
        常量 __布洛利_解码_错误_格式化_窗口_比特__: 数字;

        //@@{ __布洛利_解码_错误_无效_参数__:BROTLI_DECODER_ERROR_INVALID_ARGUMENTS }
        常量 __布洛利_解码_错误_无效_参数__: 数字;

        //@@{ __布洛利_解码_错误_不可及的__:BROTLI_DECODER_ERROR_UNREACHABLE }
        常量 __布洛利_解码_错误_不可及的__: 数字;

        //@@{ __布洛利_解码_需要_更多_输入__:BROTLI_DECODER_NEEDS_MORE_INPUT }
        常量 __布洛利_解码_需要_更多_输入__: 数字;

        //@@{ __布洛利_解码_需要_更多_输出__:BROTLI_DECODER_NEEDS_MORE_OUTPUT }
        常量 __布洛利_解码_需要_更多_输出__: 数字;

        //@@{ __布洛利_解码_无_错误__:BROTLI_DECODER_NO_ERROR }
        常量 __布洛利_解码_无_错误__: 数字;

        //@@{ __布洛利_解码_参数_禁用_环形_缓冲区_恢复位置__:BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION }
        常量 __布洛利_解码_参数_禁用_环形_缓冲区_恢复位置__: 数字;

        //@@{ __布洛利_解码_参数_太大_窗口__:BROTLI_DECODER_PARAM_LARGE_WINDOW }
        常量 __布洛利_解码_参数_太大_窗口__: 数字;

        //@@{ __布洛利_解码_结果_错误__:BROTLI_DECODER_RESULT_ERROR }
        常量 __布洛利_解码_结果_错误__: 数字;

        //@@{ __布洛利_解码_结果_需要_更多_输入__:BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT }
        常量 __布洛利_解码_结果_需要_更多_输入__: 数字;

        //@@{ __布洛利_解码_结果_需要_更多_输出__:BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT }
        常量 __布洛利_解码_结果_需要_更多_输出__: 数字;

        //@@{ __布洛利_解码_结果_成功__:BROTLI_DECODER_RESULT_SUCCESS }
        常量 __布洛利_解码_结果_成功__: 数字;

        //@@{ __布洛利_解码_成功__:BROTLI_DECODER_SUCCESS }
        常量 __布洛利_解码_成功__: 数字;

        //@@{ __布洛利_默认_模式__:BROTLI_DEFAULT_MODE }
        常量 __布洛利_默认_模式__: 数字;

        //@@{ __布洛利_默认_质量__:BROTLI_DEFAULT_QUALITY }
        常量 __布洛利_默认_质量__: 数字;

        //@@{ __布洛利_默认_窗口__:BROTLI_DEFAULT_WINDOW }
        常量 __布洛利_默认_窗口__: 数字;

        //@@{ __布洛利_编码__:BROTLI_ENCODE }
        常量 __布洛利_编码__: 数字;

        //@@{ __布洛利_太大_最大_窗口_比特__:BROTLI_LARGE_MAX_WINDOW_BITS }
        常量 __布洛利_太大_最大_窗口_比特__: 数字;

        //@@{ __布洛利_最大_输入_块_比特__:BROTLI_MAX_INPUT_BLOCK_BITS }
        常量 __布洛利_最大_输入_块_比特__: 数字;

        //@@{ __布洛利_最大_质量__:BROTLI_MAX_QUALITY }
        常量 __布洛利_最大_质量__: 数字;

        //@@{ __布洛利_最大_窗口_比特__:BROTLI_MAX_WINDOW_BITS }
        常量 __布洛利_最大_窗口_比特__: 数字;

        //@@{ __布洛利_最小_输入_块_比特__:BROTLI_MIN_INPUT_BLOCK_BITS }
        常量 __布洛利_最小_输入_块_比特__: 数字;

        //@@{ __布洛利_最小_质量__:BROTLI_MIN_QUALITY }
        常量 __布洛利_最小_质量__: 数字;

        //@@{ __布洛利_最小_窗口_比特__:BROTLI_MIN_WINDOW_BITS }
        常量 __布洛利_最小_窗口_比特__: 数字;

        //@@{ __布洛利_模式_字体__:BROTLI_MODE_FONT }
        常量 __布洛利_模式_字体__: 数字;

        //@@{ __布洛利_模式_泛型__:BROTLI_MODE_GENERIC }
        常量 __布洛利_模式_泛型__: 数字;

        //@@{ __布洛利_模式_文本__:BROTLI_MODE_TEXT }
        常量 __布洛利_模式_文本__: 数字;

        //@@{ __布洛利_操作_发出_元数据__:BROTLI_OPERATION_EMIT_METADATA }
        常量 __布洛利_操作_发出_元数据__: 数字;

        //@@{ __布洛利_操作_完成__:BROTLI_OPERATION_FINISH }
        常量 __布洛利_操作_完成__: 数字;

        //@@{ __布洛利_操作_刷新__:BROTLI_OPERATION_FLUSH }
        常量 __布洛利_操作_刷新__: 数字;

        //@@{ __布洛利_操作_进程__:BROTLI_OPERATION_PROCESS }
        常量 __布洛利_操作_进程__: 数字;

        //@@{ __布洛利_参数_禁用_文字_上下文_建模__:BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING }
        常量 __布洛利_参数_禁用_文字_上下文_建模__: 数字;

        //@@{ __布洛利_参数_太大_窗口__:BROTLI_PARAM_LARGE_WINDOW }
        常量 __布洛利_参数_太大_窗口__: 数字;

        //@@{ __布洛利_参数_LG块__:BROTLI_PARAM_LGBLOCK }
        常量 __布洛利_参数_LG块__: 数字;

        //@@{ __布洛利_参数_LG窗口__:BROTLI_PARAM_LGWIN }
        常量 __布洛利_参数_LG窗口__: 数字;

        //@@{ __布洛利_参数_模式__:BROTLI_PARAM_MODE }
        常量 __布洛利_参数_模式__: 数字;

        //@@{ __布洛利_参数_直接的__:BROTLI_PARAM_NDIRECT }
        常量 __布洛利_参数_直接的__: 数字;

        //@@{ __布洛利_参数_后缀__:BROTLI_PARAM_NPOSTFIX }
        常量 __布洛利_参数_后缀__: 数字;

        //@@{ __布洛利_参数_质量__:BROTLI_PARAM_QUALITY }
        常量 __布洛利_参数_质量__: 数字;

        //@@{ __布洛利_参数_大小_提示__:BROTLI_PARAM_SIZE_HINT }
        常量 __布洛利_参数_大小_提示__: 数字;

        //@@{ __紧缩__:DEFLATE }
        常量 __紧缩__: 数字;

        //@@{ __紧缩原料__:DEFLATERAW }
        常量 __紧缩原料__: 数字;
        常量 GUNZIP: 数字;
        常量 GZIP: 数字;

        //@@{ __充气机__:INFLATE }
        常量 __充气机__: 数字;

        //@@{ __充气机_原料__:INFLATERAW }
        常量 __充气机_原料__: 数字;
        常量 UNZIP: 数字;

        //@@{ __Z_最好的_压缩__:Z_BEST_COMPRESSION }
        常量 __Z_最好的_压缩__: 数字;

        //@@{ __Z_最好的_速度__:Z_BEST_SPEED }
        常量 __Z_最好的_速度__: 数字;

        //@@{ __Z_块__:Z_BLOCK }
        常量 __Z_块__: 数字;

        //@@{ __Z_缓冲_错误__:Z_BUF_ERROR }
        常量 __Z_缓冲_错误__: 数字;

        //@@{ __Z_数据_错误__:Z_DATA_ERROR }
        常量 __Z_数据_错误__: 数字;

        //@@{ __Z_默认_块__:Z_DEFAULT_CHUNK }
        常量 __Z_默认_块__: 数字;

        //@@{ __Z_默认的_压缩__:Z_DEFAULT_COMPRESSION }
        常量 __Z_默认的_压缩__: 数字;

        //@@{ __Z_默认_级别__:Z_DEFAULT_LEVEL }
        常量 __Z_默认_级别__: 数字;

        //@@{ __Z_默认_内存级别__:Z_DEFAULT_MEMLEVEL }
        常量 __Z_默认_内存级别__: 数字;

        //@@{ __Z_默认的_策略__:Z_DEFAULT_STRATEGY }
        常量 __Z_默认的_策略__: 数字;

        //@@{ __Z_默认_窗口_比特__:Z_DEFAULT_WINDOWBITS }
        常量 __Z_默认_窗口_比特__: 数字;

        //@@{ __Z_错误编号__:Z_ERRNO }
        常量 __Z_错误编号__: 数字;

        //@@{ __Z_过滤后__:Z_FILTERED }
        常量 __Z_过滤后__: 数字;

        //@@{ __Z_完成__:Z_FINISH }
        常量 __Z_完成__: 数字;

        //@@{ __Z_固定__:Z_FIXED }
        常量 __Z_固定__: 数字;

        //@@{ __Z_完整_刷新__:Z_FULL_FLUSH }
        常量 __Z_完整_刷新__: 数字;

        //@@{ __Z_霍夫曼_仅仅__:Z_HUFFMAN_ONLY }
        常量 __Z_霍夫曼_仅仅__: 数字;

        //@@{ __Z_最大_块__:Z_MAX_CHUNK }
        常量 __Z_最大_块__: 数字;

        //@@{ __Z_最大_级别__:Z_MAX_LEVEL }
        常量 __Z_最大_级别__: 数字;

        //@@{ __Z_最大_内存级别__:Z_MAX_MEMLEVEL }
        常量 __Z_最大_内存级别__: 数字;

        //@@{ __Z_最大_窗口_比特__:Z_MAX_WINDOWBITS }
        常量 __Z_最大_窗口_比特__: 数字;

        //@@{ __Z_内存_错误__:Z_MEM_ERROR }
        常量 __Z_内存_错误__: 数字;

        //@@{ __Z_最小_块__:Z_MIN_CHUNK }
        常量 __Z_最小_块__: 数字;

        //@@{ __Z_最小_级别__:Z_MIN_LEVEL }
        常量 __Z_最小_级别__: 数字;

        //@@{ __Z_最小_内存级别__:Z_MIN_MEMLEVEL }
        常量 __Z_最小_内存级别__: 数字;

        //@@{ __Z_最小_窗口_比特__:Z_MIN_WINDOWBITS }
        常量 __Z_最小_窗口_比特__: 数字;

        //@@{ __Z_需要_词典__:Z_NEED_DICT }
        常量 __Z_需要_词典__: 数字;

        //@@{ __Z_没有_压缩__:Z_NO_COMPRESSION }
        常量 __Z_没有_压缩__: 数字;

        //@@{ __Z_不_刷新__:Z_NO_FLUSH }
        常量 __Z_不_刷新__: 数字;

        //@@{ __Z_正确__:Z_OK }
        常量 __Z_正确__: 数字;

        //@@{ __Z_部分_刷新__:Z_PARTIAL_FLUSH }
        常量 __Z_部分_刷新__: 数字;
        常量 Z_RLE: 数字;

        //@@{ __Z_流_结束__:Z_STREAM_END }
        常量 __Z_流_结束__: 数字;

        //@@{ __Z_流_错误__:Z_STREAM_ERROR }
        常量 __Z_流_错误__: 数字;

        //@@{ __Z_同步_刷新__:Z_SYNC_FLUSH }
        常量 __Z_同步_刷新__: 数字;

        //@@{ __Z_版本_错误__:Z_VERSION_ERROR }
        常量 __Z_版本_错误__: 数字;

        //@@{ __ZLIB_版本号__:ZLIB_VERNUM }
        常量 __ZLIB_版本号__: 数字;
    }

    /**
     * @deprecated
     */

    //@@{ __Z_不_刷新__:Z_NO_FLUSH }
    常量 __Z_不_刷新__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_部分_刷新__:Z_PARTIAL_FLUSH }
    常量 __Z_部分_刷新__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_同步_刷新__:Z_SYNC_FLUSH }
    常量 __Z_同步_刷新__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_完整_刷新__:Z_FULL_FLUSH }
    常量 __Z_完整_刷新__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_完成__:Z_FINISH }
    常量 __Z_完成__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_块__:Z_BLOCK }
    常量 __Z_块__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_树__:Z_TREES }
    常量 __Z_树__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_正确__:Z_OK }
    常量 __Z_正确__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_流_结束__:Z_STREAM_END }
    常量 __Z_流_结束__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_需要_词典__:Z_NEED_DICT }
    常量 __Z_需要_词典__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_错误编号__:Z_ERRNO }
    常量 __Z_错误编号__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_流_错误__:Z_STREAM_ERROR }
    常量 __Z_流_错误__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_数据_错误__:Z_DATA_ERROR }
    常量 __Z_数据_错误__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_内存_错误__:Z_MEM_ERROR }
    常量 __Z_内存_错误__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_缓冲_错误__:Z_BUF_ERROR }
    常量 __Z_缓冲_错误__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_版本_错误__:Z_VERSION_ERROR }
    常量 __Z_版本_错误__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_没有_压缩__:Z_NO_COMPRESSION }
    常量 __Z_没有_压缩__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_最好的_速度__:Z_BEST_SPEED }
    常量 __Z_最好的_速度__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_最好的_压缩__:Z_BEST_COMPRESSION }
    常量 __Z_最好的_压缩__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_默认的_压缩__:Z_DEFAULT_COMPRESSION }
    常量 __Z_默认的_压缩__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_过滤后__:Z_FILTERED }
    常量 __Z_过滤后__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_霍夫曼_仅仅__:Z_HUFFMAN_ONLY }
    常量 __Z_霍夫曼_仅仅__: 数字;
    /**
     * @deprecated
     */
    常量 Z_RLE: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_固定__:Z_FIXED }
    常量 __Z_固定__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_默认的_策略__:Z_DEFAULT_STRATEGY }
    常量 __Z_默认的_策略__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_二进制__:Z_BINARY }
    常量 __Z_二进制__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_文本__:Z_TEXT }
    常量 __Z_文本__: 数字;
    /**
     * @deprecated
     */
    常量 Z_ASCII: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_未知__:Z_UNKNOWN }
    常量 __Z_未知__: 数字;
    /**
     * @deprecated
     */

    //@@{ __Z_无损压缩__:Z_DEFLATED }
    常量 __Z_无损压缩__: 数字;
}
